利用哈弗曼树实现文件压缩

最新推荐文章于 2021-09-23 08:36:38 发布
最新推荐文章于 2021-09-23 08:36:38 发布
阅读量830 收藏 6
点赞数 2
分类专栏： C++知识总结 文章标签： Huffman Tree 文加压缩 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tianzez/article/details/80989535
版权

一、预备知识

　　给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
　　本项目使用的Huffman Tree的K-V里面存放的是字符以及字符出现的次数，构建成Huffman Tree 大体如下：
这里写图片描述
　　根据这棵树，我们可以得到每个字符的编码，例如a的编码就是1，d的编码就是000，c的编码就是001。那么问题来了，我们要如何得到这棵数呢？得到的编码又该如何处理呢？

二、具体思路

1. 使用哈希表统计字符出现的次数

　　构建Huffman Tree我们采用贪心算法。首先要生成一张关于字符的K-V模型的哈希表（采用直接定值法）。

CharInfo _hashInfos[256];
//哈希表存储元素的信息：
struct configInfo{
    char _ch;        //字符
    LongType _count; //字符出现的次数
};

注意：此处哈希表的范围是[0, 255]，而字符的范围是[-127, 128]，所以统计字符个数时要先把字符强转成无符号类型的，例如：_hashTable[(unsigned char)ch]._count++

2. 生成Huffman Tree

  • 把哈希表中的元素插入到优先级队列中，构建小堆。
  • 从小堆每次拿两个元素进行相加，将相加后的结果依旧放回到优先级队列中，并保持小堆。
HufmanTree(W* w, size_t n, W& invalid)
{
    // 构建哈弗曼树
    priority_queue<Node*, vector<Node*>, NodeCompare> minHead;
    size_t i = 0;
    for (i = 0; i < n; ++i){
        if (w[i] != invalid)
            minHead.push(new Node(w[i]));
    }
        while (minHead.size() > 1){
        Node* left = minHead.top();
        minHead.pop();
        Node* right = minHead.top();
        minHead.pop();
        Node* parent = new Node(left->_w + right->_w);
        parent->_left = left;
        parent->_right = right;
        minHead.push(parent);
    }
    _root = minHead.top();
}

3. 生成Huffman Code

void generateHuffmanCode(Node* root)
{
    if(root == nullptr)
        return;

    if(!root->_left && !root->_right){
        _hashInfos[(unsigned char)root->_w._ch]._code = root->_w._code;
           return;
    }

    // 往左边走，把左孩子的 code 加上'0'
    if(root->_left){
        root->_left->_w._code = root->_w._code + '0';
        generateHuffmanCode(root->_left);
    }

    // 往右边走，把右孩子的 code 加上'1'
    if(root->_right){
        root->_right->_w._code = root->_w._code + '1';
        generateHuffmanCode(root->_right);
    }
}

4. 开始压缩

  • 把哈希表中的内容也写到到压缩文件中，方便解压时重建二叉树。
  • 把字符及其对应的字符编码写到压缩文件中，逐字节写入。
  • 如果写完最后一个字符且不满一字节，往里面填充0。

5. 解压缩

  • 读取文件中的哈希表，重建Huffman Tree。
  • 根据Huffman Tree和Huffman Code还原对应字符，写到解压缩文件中。
  • 根据Huffman Tree的根节点，确定解压缩的字符的个数。

三、源代码

// HuffmanTree.h

#ifndef __HUFFMANTREE_H__
#define __HUFFMANTREE_H__

#include <iostream>
#include <stdio.h>
#include <queue>
#include <vector>

// 哈弗曼树节点内容
template<class W>
class HuffmanTreeNode{
public:
    HuffmanTreeNode<W>* _left;
    HuffmanTreeNode<W>* _right;
    HuffmanTreeNode<W>* _parent;
    W _w;

    HuffmanTreeNode(const W& w)
        :_left(NULL)
        , _right(NULL)
        , _parent(NULL)
        , _w(w)
    {}
};

// 哈弗曼树
template<class W>
class HuffmanTree{
    typedef HuffmanTreeNode<W> Node;
public:
    HuffmanTree()
        :_root(NULL)
    {}

    // 仿函数（根据字符出现的次数进行比较）
    struct NodeCompare{
        bool operator()(const Node* l, const Node* r){
            return l->_w > r->_w;
        }
    };

    HuffmanTree(W* w, size_t n, W& invalid)
    {
        // 构建哈弗曼树
        priority_queue<Node*, vector<Node*>, NodeCompare> minHead;
        size_t i = 0;
        for (i = 0; i < n; ++i){
            if (w[i] != invalid)
                minHead.push(new Node(w[i]));
        }

        while (minHead.size() > 1){
            Node* left = minHead.top();
            minHead.pop();
            Node* right = minHead.top();
            minHead.pop();
            Node* parent = new Node(left->_w + right->_w);
            parent->_left = left;
            parent->_right = right;
            minHead.push(parent);
        }
        _root = minHead.top();
    }

    ~HuffmanTree()
    {
        Destory(_root);
        _root = NULL;
    }

    void Destory(Node* root)
    {
        if (root == NULL){
            return;
        }
        Destory(root->_left);
        Destory(root->_right);
        delete root;
    }

    Node* GetRoot()
    {
        return _root;
    }
private:
    HuffmanTree(const HuffmanTree<W>& t);
    HuffmanTree& operator=(const HuffmanTree<W>& t);
protected:
    Node* _root;
};

#endif //__HUFFMANTREE_H__

// FileCompress.h

#ifndef __FILECOMPRESS_H__
#define __FILECOMPRESS_H__

#include "HuffmanTree.h"
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <assert.h>
#include <string>
using namespace std;

typedef long long LongType;

struct CharInfo{
    char _ch;        //字符
    string _code;    //编码
    LongType _count; //出现次数

    // 重载+ 是为了在构建哈夫曼树时，parent = left+right
    CharInfo operator+(const CharInfo& info)
    {
        CharInfo ret;
        ret._count = _count + info._count;
        return ret;
    }

    bool operator>(const CharInfo& info) const
    {
        return _count > info._count;
    }

    bool operator != (const CharInfo& invalid)
    {
        return _count != invalid._count;
    }
};

class FileCompress{
    typedef HuffmanTreeNode<CharInfo> Node;

public:
    struct configInfo
    {
        char _ch;
        LongType _count;
    };
    FileCompress()
    {
        size_t i = 0;
        for (i = 0; i < 256; ++i){
            _hashInfos[i]._ch = i;
            _hashInfos[i]._count = 0;
        }
    }
    void Compress(const char* file)
    {
        // 1.统计文件中字符出现的次数
        ifstream ifs(file, ios_base::in | ios_base::binary);
        char ch;
        while (ifs.get(ch)){
            // 因为 char的范围是-127-128，而使用负数做下标对哈希表进行访问会出错，所以强转成无符号的
            _hashInfos[(unsigned char)ch]._count++;
        }

        // 2.生成哈弗曼树
        CharInfo invalid;
        invalid._count = 0;
        HuffmanTree<CharInfo> tree(_hashInfos, 256, invalid);

        // 3.生成 Huffman code
        generateHuffmanCode(tree.GetRoot());

        // 4.压缩
        string compressFile = file;
        // 给压缩文件添加后缀
        compressFile += ".huffman";
        ofstream ofs(compressFile.c_str(), ios_base::out | ios_base::binary);

        // 把字符和次数也写到压缩文件中，方便解压时生成 _hashInfos
        for (size_t i = 0; i < 256; ++i){
            if (_hashInfos[i]._count > 0){
                configInfo info;
                info._ch = _hashInfos[i]._ch;
                info._count = _hashInfos[i]._count;
                ofs.write((char*)&info, sizeof(configInfo));
            }
        }
        configInfo end;
        end._count = 0;
        ofs.write((char*)&end, sizeof(configInfo));

        ifs.clear();  //清理一下，下面seekg才起作用
        ifs.seekg(0);
        char value = 0;
        int pos = 0;

        //把编码写入到压缩文件中
        while (ifs.get(ch)){
            string& code = _hashInfos[(unsigned char)ch]._code;
            for (size_t i = 0; i < code.size(); ++i){
                if (code[i] == '0') value &= (~(1 << pos));
                else if (code[i] == '1') value |= (1 << pos);
                else assert(false);

                ++pos;
                if (pos == 8){
                    ofs.put(value);
                    pos = 0;
                    value = 0;
                }
            }
        }
        // 如果最后一个字节没填满，直接放进去
        if (pos > 0) ofs.put(value);
    }


    void generateHuffmanCode(Node* root)
    {
        if(root == nullptr)
            return;

        if(!root->_left && !root->_right){
            _hashInfos[(unsigned char)root->_w._ch]._code = root->_w._code;
            return;
        }

        // 往左边走，把左孩子的 code 加上'0'
        if(root->_left){
            root->_left->_w._code = root->_w._code + '0';
            generateHuffmanCode(root->_left);
        }

        // 往右边走，把右孩子的 code 加上'1'
        if(root->_right){
            root->_right->_w._code = root->_w._code + '1';
            generateHuffmanCode(root->_right);
        }
    }

    void Uncompress(const char* file)
    {
        // 1. 打开压缩文件，进行解压
        ifstream ifs(file, ios_base::in | ios_base::binary);
        string uncompressfile = file;
        size_t pos = uncompressfile.rfind('.');
        assert(pos != string::npos);
        uncompressfile.erase(pos);

        uncompressfile += ".unhuffman";
        ofstream ofs(uncompressfile.c_str(), ios_base::out | ios_base::binary);

        // 重构 _hashInfos
        while (1){
            configInfo info;
            ifs.read((char*)&info, sizeof(configInfo));
            if (info._count > 0)
            {
                _hashInfos[(unsigned char)info._ch]._count = info._count;
            }
            else
            {
                break;
            }
        }

        // 2. 重建Huffman Tree
        CharInfo invalid;
        invalid._count = 0;
        HuffmanTree<CharInfo> tree(_hashInfos, 256, invalid);

        // 3. 根据 Huffman Code 解压缩
        char ch;
        Node* root = tree.GetRoot();
        LongType fileCount = root->_w._count;  //记录了文件总字符的个数，为解压做准备

        Node* cur = root;
        while (ifs.get(ch)){
            for (size_t pos = 0; pos < 8; ++pos){

                if (ch & (1 << pos)) cur = cur->_right;  // 1
                else cur = cur->_left;                   // 0

                if (!cur->_left && !cur->_right) {       //
                    ofs.put(cur->_w._ch);
                    cur = root;

                    if (--fileCount == 0) break; // 解压完成
                }
            }
        }
    }
private:
    CharInfo _hashInfos[256];
};

void TestFileCompress()
{
    FileCompress fc;
    fc.Compress("Input.txt");
}

void TestFileUncompress()
{
    FileCompress fc;
    fc.Uncompress("Input.txt.huffman");
}

#endif //__FILECOMPRESS_H__

四、压缩率

源文件类型源文件大小压缩文件大小压缩率
txt文本文档3502kb2546kb72.70%
视频文件56.5mb56.24mb99.53%
Tianzez
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day14/15：哈夫曼树、哈弗曼编码(压缩与解压缩)
zjjaibc的博客
08-09 199
哈夫曼树、哈弗曼编码(压缩与解压缩代码实现)
哈夫曼树实现文件压缩
John的博客
11-05 5331
最近在学了哈夫曼树之后，作为练习，写了一个文件压缩的小项目； 在这里和大家分享一下；主要实现思路： 利用哈夫曼树的特性对字符进行哈夫曼编码，其中运用到了最小堆；利用最小堆的特性，找出构造哈夫曼树的结点；统计文件字符出现的次数，本质是利用字符出现的次数进行构造哈夫曼树； 然后通过遍历哈夫曼树获取哈夫曼编码；配置文件的主要内容：字符，字符出现次数，哈夫曼编码 当解压缩时可以利用配置文件中的内容构造出
基于哈夫曼编码的文本文件压缩与解压缩
10-30
基于哈夫曼编码的文本文件压缩与解压缩，使用c语言，实际只是编码解码，不应该称为解压缩，因为编码后文件会更大
用哈弗曼编码对文件进行压缩与解压
06-10
采用静态的哈弗曼编码，可以实现对文件的压缩与解压，并且可以计算压缩、解压速度，压缩率等~
基于HuffmanTree的文件压缩及解压
mac_timmy
04-05 483
个人博客传送门 HuffmanTree 定义 名词解释 性质 创建HuffmanTree 节点定义 构造函数 参数解释 构建的思想 析构函数 获取根节点函数 补充 文件压缩及解压缩 哈夫曼编码 压缩思路 压缩原理 压缩与解压代码分析 结构体分析 构造函数 压缩函数 构建哈夫曼编码函数 解压函数 代码 HuffmanTree 定义 哈弗曼树是一种...
哈夫曼树实现文件压缩和解压（源程序+实验报告）
12-02
综合实验： 1. 问题描述 利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。这要求在发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站编写一个哈夫曼码的编/译码系统。 2. 基本要求 一个完整的系统应具有以下功能： (1) I：初始化（Initialization）。从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。 (2) E：编码（Encoding）。利用已建好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。 (3) D：译码（Decoding）。利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件Textfile中。 (4) P：印代码文件（Print）。将文件CodeFile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件CodePrin中。 (5) T：印哈夫曼树（Tree printing）。将已在内存中的哈夫曼树以直观的方式（比如树）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint 中。 3. 测试数据 用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAME IS MY FAVORITE”。 字符 A B C D E F G H I J K L M 频度 186 64 13 22 32 103 21 15 47 57 1 5 32 20 字符 N O P Q R S T U V W X Y Z 频度 57 63 15 1 48 51 80 23 8 18 1 16 1
哈夫曼树实现压缩文件
weixin_45683301的博客
09-23 366
哈夫曼树实现文件的压缩
文件压缩（哈夫曼树实现）
景初浅行
04-18 1762
项目描述： 项目简介：利用哈夫曼编码的方式对文件进行压缩，并且对压缩文件可以解压 开发环境：windows vs2013 项目概述：         1.压缩             a.读取文件，将每个字符，该字符出现的次数和权值构成哈夫曼树             b.哈夫曼树是利用小堆构成，字符出现次数少的节点指针存在堆顶，出现次数多的在堆底             c.每次取
基于哈夫曼树的文件压缩
puyv_1111的博客
07-15 2664
一个编程小白成功的完成了哈夫曼树的文件压缩，过程可以说是很艰辛了。好啦~废话就不多说了，下面开始正式的讲解，过程+代码。工具：Dev-c++ 语言：C++刚开始我拿到这个题目，真心是蒙啊，因为我连什么是哈夫曼都不知道（可以看出我是小白了吧）。先说一下整个过程:1.从文件中读取叶子个数，及权值（即相同字母的个数）。比如说文件中内容是abcdabcaba,叶子个数为4，分别是a,b,c,d,权值依次为...
哈夫曼树实现文件解压缩
03-02
Huffman 构造自适应霍夫曼树实现文件的压缩与解压缩。-Adaptive Huffman tree structure for file compression and decompression. 文件列表(点击判断是否您需要的文件，如果是垃圾请在下面评价投诉): Encoder\Huffman.h .......\Encoder.cpp Decoder\Huffman.h .......\Decoder.cpp Encoder Decoder
建立哈夫曼树 并用其编写解压和解压缩文件的程序
11-21
1、根据给定的一个文本文件，读出其内容，统计各个字符出现的频度，建立哈夫曼树，求出各个字符的哈夫曼码；打印哈夫曼树形结构，然后对文件进行编码；最后，对编码后的文件在解码，对哈夫曼算法进行验证。 扩展功能：对文件进行压缩、解压缩。
数据结构实践课-哈夫曼树-文件的压缩解压(MFC)
03-23
数据结构实践课-哈夫曼树-文件的压缩解压(MFC)
哈夫曼树压缩算法实现
04-23
这是我做的一个基于哈夫曼树思想的压缩算法程序源码，希望大家指正
哈夫曼树压缩与解压算法
12-20
哈夫曼树源代码，不同于流行的算法。数据结构课程相关。
哈弗曼树实现文件压缩
07-04
利用huffman树实现字符文档的压缩
c语言哈弗曼树实现的文本压缩程序
09-08
c语言，数据结构是哈弗曼树，，在代码内部main函数的collect函数中将wenzi.txt修改为要压缩的文本文件，编译运行后生成.code,.code.b,.code.b.source文件 .code.b是压缩后的01文件，.code.b.source是按照.code.b解...
利用哈弗曼编码实现文件压缩和恢复
01-07
采用哈弗曼编码思想实现文件的压缩和恢复功能，并提供压缩前后占用空间之比。 描述压缩基本符号的选择方法； 运行时原文件的规模不小于5K； 提供恢复文件和文件的相同性对比功能 完整的课程设计报告 还有源代码
C语言实现哈夫曼编码压缩和解压各种文件
11-19
实验内容：写出程序，利用哈弗曼编码实现对文件的压缩，并能解压文件。 实验步骤： 1、压缩 （1） 统计原始文件中各字节出现的概率（次数）； （2） 采用哈弗曼算法对各字节进行编码，建立哈弗曼对照表； a) 构造...
c++哈弗曼树编码译码
最新发布
12-27
哈夫曼树编码是一种通过构建最优前缀编码树来实现数据压缩的方法。首先，我们需要统计待编码的字符出现的频率，并根据频率构建哈夫曼树。在哈弗曼树中，出现频率越高的字符，其在树中的位置越靠近根节点。 在进行编码时，我们从哈弗曼树的根节点开始，沿着路径向下，对于左子树走向的路径标记为0，右子树走向的路径标记为1，直到叶子节点。这样，我们就可以得到每个字符对应的哈弗曼编码。 在解码时，我们同样从哈弗曼树的根节点开始，根据编码的0和1分别向左或向右移动，直到叶子节点，得到对应的字符。 通过哈弗曼编码，我们可以用较短的编码表示出现频率高的字符，从而实现了数据的压缩。同时，哈弗曼编码是无损压缩，即可以完全还原原始数据，因为每个字符对应的编码都是唯一的。 哈弗曼编码是一种非常有效的压缩技术，在数据传输、存储和通信等领域都有广泛的应用。通过构建哈弗曼树，对数据进行编码和译码，可以大大提高数据的压缩效率，减少存储空间和传输带宽的消耗。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值